// background.js - 云链方舟插件后台脚本

// Cookie存储变量
let storedCookies = null;

// 京东专用：网络请求规则ID（与DKD保持一致，只有一个规则）
const JD_NET_REQUEST_RULE_ID = 1;

// 京东专用：检查是否为京东平台
function isJdPlatform(cookieDomain) {
    return cookieDomain && cookieDomain.toLowerCase().includes('jddj.com');
}

// 抖店专用：检查是否为抖店平台
function isDoudianPlatform(cookieDomain) {
    return cookieDomain && cookieDomain.toLowerCase().includes('jinritemai.com');
}

// 京东专用：启用网络请求规则（修改Origin头）
async function enableJdNetRequestRule() {
    try {
        // 先尝试移除可能已存在的规则，避免ID冲突（与DKD保持一致）
        try {
            await chrome.declarativeNetRequest.updateDynamicRules({
                removeRuleIds: [JD_NET_REQUEST_RULE_ID]
            });
        } catch (removeError) {
            // 如果规则不存在，忽略错误
        }

        // 规则：拦截 sff.jddj.com（与DKD完全一致）
        const rule = {
            id: JD_NET_REQUEST_RULE_ID,
            priority: 1,
            action: {
                type: "modifyHeaders",
                requestHeaders: [
                    {
                        header: "Origin",
                        operation: "set",
                        value: "https://store.jddj.com"
                    }
                ]
            },
            condition: {
                urlFilter: "https://sff.jddj.com",
                excludedDomains: ["store-hub.jddj.com", "cloud.jddj.com"],
                resourceTypes: ["xmlhttprequest", "script"]
            }
        };

        await chrome.declarativeNetRequest.updateDynamicRules({
            addRules: [rule]
        });
    } catch (error) {
        // 忽略错误
    }
}

// 京东专用：移除网络请求规则（与DKD保持一致）
async function disableJdNetRequestRule() {
    try {
        await chrome.declarativeNetRequest.updateDynamicRules({
            removeRuleIds: [JD_NET_REQUEST_RULE_ID]
        });
    } catch (error) {
        // 如果规则不存在，忽略错误（这是正常的）
    }
}

// 京东专用：处理京东登录流程
async function handleJdLogin(request, sender, sendResponse) {
    try {
        const { loginUrl, cookieDomain } = request;

        if (!loginUrl || !cookieDomain) {
            sendResponse({
                success: false,
                error: '缺少必要参数: loginUrl 和 cookieDomain'
            });
            return;
        }

        // 保存原始页面的Tab ID
        const originalTabId = sender.tab ? sender.tab.id : null;

        // 1. 清除该域名下的所有cookies（登录时不需要启用规则）
        await clearCookiesForDomain(cookieDomain);

        // 2. 打开登录页面（不启用规则，让登录页面正常加载）
        const tab = await chrome.tabs.create({
            url: loginUrl,
            active: true
        });

        // 开始监听cookies变化（京东使用store_session作为登录关键字）
        // 注意：登录时不需要启用规则，规则只在设置cookies后启用
        const loginKeyword = request.loginKeyword || 'store_session';
        startCookieMonitoring(tab.id, cookieDomain, loginKeyword, originalTabId, false); // 登录时isJdPlatform设为false，不启用规则

        sendResponse({
            success: true,
            message: '新标签页已创建，开始监听cookies'
        });

    } catch (error) {
        // 如果出错，确保移除规则
        await disableJdNetRequestRule();
        sendResponse({
            success: false,
            error: error.message || '处理失败'
        });
    }
}

// 监听来自Web项目的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {

    switch (request.action) {
        case 'ping':
            const pingResponse = {
                success: true,
                version: '1.0.0',
                pluginName: '云链方舟插件',
                message: 'Background script响应正常'
            };
            sendResponse(pingResponse);
            break;

        case 'clearAndWaitForCookies':
            handleClearAndWaitForCookies(request, sender, sendResponse);
            return true; // 异步响应

        case 'getStoredCookies':
            handleGetStoredCookies(sendResponse);
            break;

        case 'setCookiesAndOpenUrl':
            handleSetCookiesAndOpenUrl(request, sender, sendResponse);
            return true; // 异步响应

        default:
            sendResponse({ success: false, error: '未知操作' });
    }
    return true;
});

// 处理清除cookies并开始监听
async function handleClearAndWaitForCookies(request, sender, sendResponse) {
    try {
        const { loginUrl, cookieDomain } = request;

        if (!loginUrl || !cookieDomain) {
            sendResponse({
                success: false,
                error: '缺少必要参数: loginUrl 和 cookieDomain'
            });
            return;
        }

        // 判断是否为京东平台，使用专门的京东处理逻辑
        if (isJdPlatform(cookieDomain)) {
            await handleJdLogin(request, sender, sendResponse);
            return;
        }

        // 保存原始页面的Tab ID
        const originalTabId = sender.tab ? sender.tab.id : null;

        // 先清除该域名下的所有cookies
        await clearCookiesForDomain(cookieDomain);

        // 打开登录页面
        const tab = await chrome.tabs.create({
            url: loginUrl,
            active: true
        });

        // 开始监听cookies变化
        startCookieMonitoring(tab.id, cookieDomain, request.loginKeyword, originalTabId, false);

        sendResponse({
            success: true,
            message: '新标签页已创建，开始监听cookies'
        });

    } catch (error) {
        sendResponse({
            success: false,
            error: error.message || '处理失败'
        });
    }
}

// 清除指定域名下的所有cookies
async function clearCookiesForDomain(cookieDomain) {
    try {
        // 获取主域名（例如：e.waimai.meituan.com -> meituan.com）
        const domainParts = cookieDomain.split('.');
        const mainDomain = domainParts.length >= 2 ? '.' + domainParts.slice(-2).join('.') : cookieDomain;

        // 获取所有相关的cookies（包括主域名和子域名）
        const allCookies = await chrome.cookies.getAll({ domain: cookieDomain });
        const mainDomainCookies = await chrome.cookies.getAll({ domain: mainDomain });

        // 合并并去重
        const cookiesMap = new Map();
        [...allCookies, ...mainDomainCookies].forEach(cookie => {
            const key = `${cookie.domain}${cookie.path}${cookie.name}`;
            if (!cookiesMap.has(key)) {
                cookiesMap.set(key, cookie);
            }
        });

        // 删除每个cookie
        for (const cookie of cookiesMap.values()) {
            try {
                await chrome.cookies.remove({
                    url: `http${cookie.secure ? 's' : ''}://${cookie.domain.replace(/^\./, '')}${cookie.path || '/'}`,
                    name: cookie.name
                });
            } catch (error) {
                // 忽略删除单个cookie的错误
            }
        }
    } catch (error) {
        // 忽略清除cookies的错误
    }
}

// 开始监听cookies变化
function startCookieMonitoring(tabId, cookieDomain, loginKeyword, originalTabId, isJdPlatform = false) {
    let attempts = 0;
    const maxAttempts = 180; // 3分钟 = 180秒
    let lastCookies = '';
    let tabClosed = false; // 标记标签页是否已关闭

    const cookieMonitor = setInterval(async () => {
        attempts++;

        try {
            // 首先检查标签页是否还存在（避免重复检查已关闭的标签页）
            if (!tabClosed) {
                try {
                    await chrome.tabs.get(tabId);
                } catch (tabError) {
                    // 标签页不存在，停止监控
                    tabClosed = true;
                    clearInterval(cookieMonitor);
                    
                    // 如果是京东平台，清理网络请求规则
                    if (isJdPlatform) {
                        await disableJdNetRequestRule();
                    }
                    
                    // 通知原始页面标签页已关闭
                    await notifyTabClosed(originalTabId);
                    return;
                }
            }

            // 如果标签页已关闭，直接返回
            if (tabClosed) {
                return;
            }

            // 获取当前页面的cookies
            // 登录流程中（isJdPlatform=false），即使是京东平台也使用document.cookie（避免在登录时使用Cookies API影响登录接口）
            // 设置cookies后（isJdPlatform=true），再使用Cookies API获取HttpOnly cookies
            const currentCookies = await getPageCookies(tabId, isJdPlatform ? cookieDomain : null);

            // 检查是否有新的认证cookies
            if (hasNewAuthCookies(lastCookies, currentCookies, cookieDomain, loginKeyword)) {
                // 存储cookies
                let cookiesToStore = currentCookies;

                // 京东平台：登录成功后再使用Cookies API获取完整cookie（包含HttpOnly）
                // 先检查document.cookie是否已获取到store_session
                const hasStoreSessionInDocCookie = currentCookies.includes('store_session');
                
                if (cookieDomain && cookieDomain.toLowerCase().includes('jddj.com') && hasStoreSessionInDocCookie) {
                    try {
                        const fullCookies = await getPageCookies(tabId, cookieDomain);
                        if (fullCookies) {
                            cookiesToStore = fullCookies;
                        }
                    } catch (jdCookieError) {
                        // 使用document.cookie结果
                    }
                }
                
                // 抖店平台：登录成功后再使用Cookies API获取完整cookie（包含HttpOnly）
                // 先检查document.cookie是否已获取到csrf_session_id
                const hasCsrfSessionInDocCookie = currentCookies.includes('csrf_session_id');
                
                if (cookieDomain && cookieDomain.toLowerCase().includes('jinritemai.com') && hasCsrfSessionInDocCookie) {
                    try {
                        const fullCookies = await getPageCookies(tabId, cookieDomain);
                        if (fullCookies) {
                            cookiesToStore = fullCookies;
                        }
                    } catch (douDianCookieError) {
                        // 使用document.cookie结果
                    }
                }

                // 美团经营宝平台：登录成功后再使用Cookies API获取完整cookie（包含HttpOnly）
                // 先检查document.cookie是否已获取到EBDFPID
                const hasEBDFPIDInDocCookie = currentCookies.includes('EBDFPID');
                
                if (cookieDomain && cookieDomain.toLowerCase().includes('ecom.meituan.com') && hasEBDFPIDInDocCookie) {
                    try {
                        const fullCookies = await getPageCookies(tabId, cookieDomain);
                        if (fullCookies) {
                            cookiesToStore = fullCookies;
                        }
                    } catch (meituanEcomCookieError) {
                        // 使用document.cookie结果
                    }
                }

                // 饿了么平台：登录成功后再使用Cookies API获取完整cookie（包含HttpOnly）
                // 先检查document.cookie是否已获取到ksid
                const hasKsidInDocCookie = currentCookies.includes('ksid');
                
                if (cookieDomain && cookieDomain.toLowerCase().includes('ele.me') && hasKsidInDocCookie) {
                    try {
                        const fullCookies = await getPageCookies(tabId, cookieDomain);
                        if (fullCookies) {
                            cookiesToStore = fullCookies;
                        }
                    } catch (elemeCookieError) {
                        // 使用document.cookie结果
                    }
                }

                storedCookies = cookiesToStore;

                // 不要再监听
                clearInterval(cookieMonitor);

                // 如果是京东平台，清理网络请求规则
                if (isJdPlatform) {
                    await disableJdNetRequestRule();
                }

                // 切换回原始页面并通知
                await handleLoginSuccess(originalTabId, tabId);

                return;
            }

            lastCookies = currentCookies;

            // 检查超时
            if (attempts >= maxAttempts) {
                clearInterval(cookieMonitor);

                // 如果是京东平台，清理网络请求规则
                if (isJdPlatform) {
                    await disableJdNetRequestRule();
                }

                // 通知原始页面登录超时
                await notifyTabClosed(originalTabId, true);

                // 关闭登录页面
                try {
                    await chrome.tabs.remove(tabId);
                } catch (error) {
                    // 忽略关闭失败
                }
            }
        } catch (error) {
            // 如果是标签页不存在的错误，标记并停止
            if (error.message && error.message.includes('No tab with id')) {
                tabClosed = true;
                clearInterval(cookieMonitor);
                
                if (isJdPlatform) {
                    await disableJdNetRequestRule();
                }
                
                // 通知原始页面标签页已关闭
                await notifyTabClosed(originalTabId);
                return;
            }
            // 其他错误忽略
        }
    }, 1000); // 每秒检查一次
}

// 通知原始页面标签页已关闭或登录超时
async function notifyTabClosed(originalTabId, isTimeout = false) {
    if (!originalTabId) {
        return;
    }
    
    try {
        // 通知原始页面登录标签页已关闭或超时
        await chrome.tabs.sendMessage(originalTabId, {
            type: 'AUTH_CANCELLED',
            message: isTimeout ? '登录超时，请重新尝试' : '登录标签页已关闭，请重新尝试'
        });
    } catch (error) {
        // 如果发送消息失败，尝试刷新页面（让页面自己检测状态）
        try {
            await chrome.tabs.reload(originalTabId);
        } catch (reloadError) {
            // 忽略刷新失败
        }
    }
}

// 处理登录成功
async function handleLoginSuccess(originalTabId, loginTabId) {
    try {
        // 切换到原始页面
        if (originalTabId) {
            try {
                // 激活原始页面
                await chrome.tabs.update(originalTabId, { active: true });

                // 通知原始页面授权成功（不刷新页面，由页面自己处理状态更新）
                try {
                    await chrome.tabs.sendMessage(originalTabId, {
                        type: 'AUTH_SUCCESS',
                        message: '店铺授权成功！'
                    });
                } catch (error) {
                    // 如果发送消息失败，可能是content script未加载，尝试刷新页面
                    await chrome.tabs.reload(originalTabId);
                }
            } catch (error) {
                // 忽略切换失败
            }
        }

        // 延迟关闭登录页面（让用户看到成功提示）
        setTimeout(async () => {
            try {
                await chrome.tabs.remove(loginTabId);
            } catch (error) {
                // 忽略关闭失败
            }
        }, 1500); // 1.5秒后关闭登录页面

    } catch (error) {
        // 如果出错，直接关闭登录页面
        try {
            await chrome.tabs.remove(loginTabId);
        } catch (e) {
            // 忽略
        }
    }
}

// 获取页面cookies
async function getPageCookies(tabId, cookieDomain = null) {
    try {
        // 首先检查标签页是否还存在（避免在已关闭的标签页上执行脚本）
        let tab;
        try {
            tab = await chrome.tabs.get(tabId);
        } catch (tabError) {
            // 标签页不存在（已被关闭）
            // 不打印警告，直接返回空字符串（因为调用方应该已经处理了标签页关闭的情况）
            return ''; // 直接返回空字符串，不再尝试获取
        }
        
        // 京东平台特殊处理：使用Chrome Cookies API获取（可以获取HttpOnly cookies）
        if (cookieDomain && isJdPlatform(cookieDomain)) {
            try {
                // 再次确认标签页存在
                if (!tab || !tab.url) {
                    // 不打印警告，调用方已经处理了标签页关闭的情况
                    return '';
                }
                
                const urlObj = new URL(tab.url);
                const domain = urlObj.hostname;
                
                // 使用Chrome Cookies API获取所有cookies（包括HttpOnly）
                const allCookies = await chrome.cookies.getAll({ domain: domain });
                
                // 京东平台：同时获取多个父域的cookies（.jddj.com 和 .jd.com）
                const parts = domain.split('.');
                const parentDomains = [];
                if (parts.length >= 2) {
                    parentDomains.push(parts.slice(-2).join('.')); // .jddj.com
                    // 如果是jddj.com，还要获取jd.com
                    if (parts.slice(-2).join('.') === 'jddj.com') {
                        parentDomains.push('jd.com');
                    }
                }
                
                let parentCookies = [];
                for (const parentDomain of parentDomains) {
                    try {
                        const cookies = await chrome.cookies.getAll({ domain: parentDomain });
                        parentCookies.push(...cookies);
                    } catch (_) {}
                }
                
                // 合并所有cookies，去重
                const cookieMap = new Map();
                [...allCookies, ...parentCookies].forEach(cookie => {
                    // 使用 name+domain 作为key去重
                    const key = `${cookie.name}:${cookie.domain || domain}`;
                    if (!cookieMap.has(key)) {
                        cookieMap.set(key, cookie);
                    }
                });
                
                // 转换为cookie字符串格式
                const cookieString = Array.from(cookieMap.values())
                    .map(c => `${c.name}=${c.value}`)
                    .join('; ');
                
                return cookieString;
            } catch (error) {
                // 如果标签页不存在，不再回退到document.cookie
                if (error.message && error.message.includes('No tab with id')) {
                    return '';
                }
            }
        }
        
        // 抖店平台特殊处理：使用Chrome Cookies API获取（可以获取HttpOnly cookies）
        if (cookieDomain && isDoudianPlatform(cookieDomain)) {
            try {
                // 再次确认标签页存在
                if (!tab || !tab.url) {
                    return '';
                }
                
                const urlObj = new URL(tab.url);
                const domain = urlObj.hostname;
                
                // 使用Chrome Cookies API获取所有cookies（包括HttpOnly）
                const allCookies = await chrome.cookies.getAll({ domain: domain });
                
                // 抖店平台：同时获取父域的cookies（.jinritemai.com）
                const parts = domain.split('.');
                const parentDomains = [];
                if (parts.length >= 2) {
                    parentDomains.push(parts.slice(-2).join('.')); // .jinritemai.com
                }
                
                let parentCookies = [];
                for (const parentDomain of parentDomains) {
                    try {
                        const cookies = await chrome.cookies.getAll({ domain: parentDomain });
                        parentCookies.push(...cookies);
                    } catch (_) {}
                }
                
                // 合并所有cookies，去重
                const cookieMap = new Map();
                [...allCookies, ...parentCookies].forEach(cookie => {
                    // 使用 name+domain 作为key去重
                    const key = `${cookie.name}:${cookie.domain || domain}`;
                    if (!cookieMap.has(key)) {
                        cookieMap.set(key, cookie);
                    }
                });
                
                // 转换为cookie字符串格式
                const cookieString = Array.from(cookieMap.values())
                    .map(c => `${c.name}=${c.value}`)
                    .join('; ');
                
                return cookieString;
            } catch (error) {
                if (error.message && error.message.includes('No tab with id')) {
                    return '';
                }
            }
        }
        
        // 美团经营宝平台特殊处理：使用Chrome Cookies API获取（可以获取HttpOnly cookies）
        if (cookieDomain && cookieDomain.toLowerCase().includes('ecom.meituan.com')) {
            try {
                // 再次确认标签页存在
                if (!tab || !tab.url) {
                    return '';
                }
                
                const urlObj = new URL(tab.url);
                const domain = urlObj.hostname;
                
                // 使用Chrome Cookies API获取所有cookies（包括HttpOnly）
                const allCookies = await chrome.cookies.getAll({ domain: domain });
                
                // 美团经营宝平台：同时获取父域的cookies（.meituan.com）
                const parts = domain.split('.');
                const parentDomains = [];
                if (parts.length >= 2) {
                    parentDomains.push(parts.slice(-2).join('.')); // .meituan.com
                }
                
                let parentCookies = [];
                for (const parentDomain of parentDomains) {
                    try {
                        const cookies = await chrome.cookies.getAll({ domain: parentDomain });
                        parentCookies.push(...cookies);
                    } catch (_) {}
                }
                
                // 合并所有cookies，去重
                const cookieMap = new Map();
                [...allCookies, ...parentCookies].forEach(cookie => {
                    // 使用 name+domain 作为key去重
                    const key = `${cookie.name}:${cookie.domain || domain}`;
                    if (!cookieMap.has(key)) {
                        cookieMap.set(key, cookie);
                    }
                });
                
                // 转换为cookie字符串格式
                const cookieString = Array.from(cookieMap.values())
                    .map(c => `${c.name}=${c.value}`)
                    .join('; ');
                
                return cookieString;
            } catch (error) {
                if (error.message && error.message.includes('No tab with id')) {
                    return '';
                }
            }
        }
        
        // 饿了么平台特殊处理：使用Chrome Cookies API获取（可以获取HttpOnly cookies）
        if (cookieDomain && cookieDomain.toLowerCase().includes('ele.me')) {
            try {
                // 再次确认标签页存在
                if (!tab || !tab.url) {
                    return '';
                }
                
                const urlObj = new URL(tab.url);
                const domain = urlObj.hostname;
                
                // 使用Chrome Cookies API获取所有cookies（包括HttpOnly）
                const allCookies = await chrome.cookies.getAll({ domain: domain });
                
                // 饿了么平台：同时获取父域的cookies（.ele.me）
                const parts = domain.split('.');
                const parentDomains = [];
                if (parts.length >= 2) {
                    parentDomains.push(parts.slice(-2).join('.')); // .ele.me
                }
                
                let parentCookies = [];
                for (const parentDomain of parentDomains) {
                    try {
                        const cookies = await chrome.cookies.getAll({ domain: parentDomain });
                        parentCookies.push(...cookies);
                    } catch (_) {}
                }
                
                // 合并所有cookies，去重
                const cookieMap = new Map();
                [...allCookies, ...parentCookies].forEach(cookie => {
                    // 使用 name+domain 作为key去重
                    const key = `${cookie.name}:${cookie.domain || domain}`;
                    if (!cookieMap.has(key)) {
                        cookieMap.set(key, cookie);
                    }
                });
                
                // 转换为cookie字符串格式
                const cookieString = Array.from(cookieMap.values())
                    .map(c => `${c.name}=${c.value}`)
                    .join('; ');
                
                return cookieString;
            } catch (error) {
                if (error.message && error.message.includes('No tab with id')) {
                    return '';
                }
            }
        }
        
        // 其他平台或京东平台回退：使用scripting API获取cookies（document.cookie）
        // 再次检查标签页是否存在
        try {
            await chrome.tabs.get(tabId);
        } catch (tabCheckError) {
            return '';
        }
        
        const results = await chrome.scripting.executeScript({
            target: { tabId: tabId },
            function: () => {
                return document.cookie;
            }
        });

        const cookies = results[0].result || '';
        return cookies;
    } catch (error) {
        // 如果是标签页不存在的错误，不再报错
        if (error.message && error.message.includes('No tab with id')) {
            return '';
        }
        return '';
    }
}

// 检查是否有新的认证cookies
function hasNewAuthCookies(oldCookies, newCookies, cookieDomain, loginKeyword) {
    // 1. 检查cookies数量是否增加
    if (newCookies.length <= oldCookies.length) {
        return false;
    }

    // 2. 检查是否包含登录成功关键字
    const hasLoginKeyword = loginKeyword && newCookies.includes(loginKeyword);
    
    // 3. 如果是京东平台，检测store_session（登录成功标识）
    if (cookieDomain && cookieDomain.toLowerCase().includes('jddj.com')) {
        const hasStoreSession = newCookies.includes('store_session');
        if (hasStoreSession) {
            return true;
        }
    }

    // 4. 如果是抖店平台，检测csrf_session_id（登录成功标识）
    // 注意：passport_csrf_token 在未登录时也存在，不能作为登录标识
    if (cookieDomain && cookieDomain.toLowerCase().includes('jinritemai.com')) {
        const hasCsrfSession = newCookies.includes('csrf_session_id');
        if (hasCsrfSession) {
            return true;
        }
    }

    // 5. 如果是美团经营宝平台，必须同时检测EBDFPID和bizType=1（登录成功标识）
    // 登录前：WEBDFPID + bizType=-1
    // 登录后：EBDFPID + bizType=1
    // 注意：WEBDFPID 包含 EBDFPID 字符串，必须使用正则精确匹配 cookie 名称，不能使用 includes
    if (cookieDomain && cookieDomain.toLowerCase().includes('ecom.meituan.com')) {
        // 检测 bizType=1，这是最可靠的登录标识（登录后一定是1，登录前是-1）
        const bizTypeMatch = newCookies.match(/bizType\s*=\s*1(?:[;\s]|$)/);
        const hasBizType1 = bizTypeMatch !== null;
        
        if (hasBizType1) {
            // 有 bizType=1 就说明登录成功了
            return true;
        }
        
        // 如果没有 bizType=1，即使有 EBDFPID 也不能判定为登录成功
        // 因为可能在页面加载过程中出现其他状态
        return false;
    }

    return hasLoginKeyword;
}

// 获取存储的cookies
function handleGetStoredCookies(sendResponse) {
    if (storedCookies) {
        const cookies = storedCookies;
        storedCookies = null; // 清除存储的cookies
        sendResponse({ success: true, cookies: cookies });
    } else {
        sendResponse({ success: false, message: '暂无cookies' });
    }
}

// 处理设置cookies并打开URL（在页面中通过document.cookie设置）
async function handleSetCookiesAndOpenUrl(request, sender, sendResponse) {
    try {
        const { cookies, targetUrl } = request;

        if (!cookies || !targetUrl) {
            sendResponse({
                success: false,
                error: '缺少必要参数: cookies 和 targetUrl'
            });
            return;
        }

        // 解析targetUrl获取域名信息
        let urlObj;
        try {
            urlObj = new URL(targetUrl);
        } catch (error) {
            sendResponse({
                success: false,
                error: '无法解析targetUrl'
            });
            return;
        }

        const domain = urlObj.hostname;
        const baseUrl = `${urlObj.protocol}//${domain}`;
        const parts = domain.split('.');
        const parentDomain = parts.length >= 2 ? `.${parts.slice(-2).join('.')}` : null;

        // 平台配置：按目标域决定白名单与额外同步
        const getPlatformConfig = (host) => {
            const lower = host.toLowerCase();
            // 默认：不过滤键名，不做额外同步，不清理相关域
            const defaultCfg = { allow: null, block: null, extraSync: null, relatedDomains: null };
            if (lower.includes('meituan.com')) {
                // 美团外卖（e.waimai.meituan.com）：白名单模式
                if (lower.endsWith('e.waimai.meituan.com')) {
                    return {
                        allow: new Set(['token', 'acctId', 'wmPoiId', '_lxsdk', '_lxsdk_s', 'uuid_update', 'device_uuid']),
                        extraSync: async (name, value) => {
                            try {
                                await chrome.cookies.set({
                                    url: 'https://waimaieapp.meituan.com/ad/v1/rpc',
                                    name,
                                    value,
                                    path: '/',
                                    expirationDate
                                });
                            } catch (_) { }
                        }
                    };
                }
                // 美团经营宝（ecom.meituan.com）：全量写入
                if (lower.includes('ecom.meituan.com')) {
                    return {
                        allow: null,
                        block: null,
                        extraSync: null,
                        relatedDomains: ['ecom.meituan.com'], // 清理经营宝相关域
                        isMeituanEcomPlatform: true
                    };
                }
                // 其他美团平台默认处理
                return {
                    allow: new Set(['token', 'acctId', 'wmPoiId', '_lxsdk', '_lxsdk_s', 'uuid_update', 'device_uuid']),
                    extraSync: null
                };
            }
            if (lower.includes('nr.ele.me')) {
                // 饿百零售：全量写入，同时写入父域形式（.nr.ele.me 和 .ele.me）
                return {
                    allow: null,
                    block: null,
                    relatedDomains: ['nr.ele.me'], // 只清理零售相关域
                    extraSync: async (name, value) => {
                        // 写入父域形式：.nr.ele.me
                        try { await chrome.cookies.set({ url: 'https://nr.ele.me', name, value, path: '/', domain: '.nr.ele.me', expirationDate }); } catch (_) { }
                        // 写入更上级父域：.ele.me
                        try { await chrome.cookies.set({ url: 'https://nr.ele.me', name, value, path: '/', domain: '.ele.me', expirationDate }); } catch (_) { }
                    }
                };
            } else if (lower.includes('ele.me')) {
                // 饿了么商家：全量写入，同步到常用子域（与dkd保持一致，不屏蔽arms_uid）
                return {
                    allow: null,
                    block: null, // 不屏蔽任何键，全量写入
                    relatedDomains: ['shop.ele.me', 'app-api.shop.ele.me'], // 只清理商家相关域
                    extraSync: async (name, value) => {
                        const syncHosts = ['https://shop.ele.me', 'https://app-api.shop.ele.me'];
                        for (const h of syncHosts) {
                            try {
                                await chrome.cookies.set({ url:
                                     h, name, value, path: '/', expirationDate });
                            } catch (_) { }
                        }
                    }
                };
            }
            if (lower.includes('jddj.com')) {
                // 京东到家：全量写入，不进行白名单过滤（与dkd保持一致）
                return {
                    allow: null,
                    block: null,
                    extraSync: null, // 不移除同步（与DKD保持一致）
                    relatedDomains: ['store.jddj.com', 'sff.jddj.com'], // 清理京东相关域
                    // 京东专用：设置cookies时可能需要启用网络请求规则
                    isJdPlatform: true
                };
            }
            if (lower.includes('jinritemai.com')) {
                // 抖店：全量写入，不进行白名单过滤
                return {
                    allow: null,
                    block: null,
                    extraSync: null,
                    relatedDomains: ['fxg.jinritemai.com', 'jsls.jinritemai.com'], // 清理抖店相关域
                    isDoudianPlatform: true
                };
            }
            return defaultCfg;
        };
        const platformCfg = getPlatformConfig(domain);

        // 解析cookies字符串
        const cookiePairs = cookies.split(';');

        // 在打开页面前，先使用Chrome Cookies API设置cookies
        const expirationDate = Math.floor(Date.now() / 1000) + (7 * 24 * 60 * 60); // 7天后过期
        let toSet = [];
        const desiredMap = new Map();
        const allow = platformCfg.allow; // null 表示不过滤
        const block = platformCfg.block; // Set 表示屏蔽写入的键
        for (let i = 0; i < cookiePairs.length; i++) {
            const trimmed = cookiePairs[i].trim();
            if (!trimmed) continue;
            const eq = trimmed.indexOf('=');
            if (eq <= 0) continue;
            const name = trimmed.substring(0, eq).trim();
            const value = trimmed.substring(eq + 1).trim();
            if (!name) continue;
            if (allow && !allow.has(name)) continue;
            if (block && block.has(name)) continue;
            // 以“最后一个同名键生效”为准
            desiredMap.set(name, value);
        }

        // 统一从 desiredMap 输出要写入的键，避免同名重复写入
        toSet = Array.from(desiredMap.entries()).map(([name, value]) => ({ name, value }));

        // 写入前清理：全量删除目标域及相关子域的所有Cookie（与dkd保持一致）
        try {
            await clearCookiesForDomain(domain);
            if (parentDomain) {
                try { await clearCookiesForDomain(parentDomain.replace(/^\./, '')); } catch (_) { }
            }
            // 按平台配置清理相关域（避免跨平台清理）
            if (platformCfg && platformCfg.relatedDomains) {
                for (const h of platformCfg.relatedDomains) {
                    try { await clearCookiesForDomain(h); } catch (_) { }
                }
            }
        } catch (_) { /* ignore */ }

        // 可选：写入父域形式的 Cookie（如 .ele.me）。通过 request.needDomain 控制
        const needDomain = Boolean(request.needDomain);

        // 京东平台特殊处理：需要设置到父域（.jddj.com）
        const isJd = platformCfg.isJdPlatform;
        
        for (let i = 0; i < toSet.length; i++) {
            const { name, value } = toSet[i];
            
            try {
                // 基本设置：设置到当前域名
                await chrome.cookies.set({
                    url: baseUrl,
                    name,
                    value,
                    path: '/',
                    expirationDate
                });
            } catch (e) { 
                // 忽略错误
            }

            // 京东平台：同时设置到父域 .jddj.com（重要！）
            if (isJd && parentDomain) {
                try {
                    await chrome.cookies.set({
                        url: baseUrl,
                        name,
                        value,
                        path: '/',
                        domain: parentDomain, // 设置为 .jddj.com
                        expirationDate
                    });
                } catch (e) {
                    // 某些cookie可能无法设置到父域，这是正常的，忽略错误
                }
            }

            if (needDomain && parentDomain && !isJd) {
                try {
                    await chrome.cookies.set({
                        url: baseUrl,
                        name,
                        value,
                        path: '/',
                        domain: parentDomain,
                        expirationDate
                    });
                } catch (_) { }
            }

            // 平台额外同步（如美团同步到 waimaieapp）
            if (platformCfg.extraSync) {
                try { await platformCfg.extraSync(name, value); } catch (_) { }
            }
        }
        
        // 结束设置，准备打开目标页面

        // 如果是京东平台，在打开页面之前就启用网络请求规则（重要！）
        if (platformCfg.isJdPlatform) {
            await enableJdNetRequestRule();
        }

        // 写入完成后稍作延迟，避免浏览器/扩展异步落盘与新标签页的并发竞态
        await new Promise(r => setTimeout(r, 200)); // 增加延迟到200ms，确保Cookies写入完成

        // 若为抖店场景，自动拼接 mfa/homepage
        let finalTargetUrl = targetUrl;
        try {
            const hostL = domain.toLowerCase();
            console.log('[抖店调试] 原始targetUrl:', targetUrl);
            console.log('[抖店调试] 解析domain:', domain);
            console.log('[抖店调试] hostL:', hostL);
            
            // 抖店平台：如果目标URL是 fxg.jinritemai.com 或 jsls.jinritemai.com，统一转换为 https://jsls.jinritemai.com/mfa/homepage
            const isDoudianFxgHost = hostL.includes('fxg.jinritemai.com');
            const isDoudianJslsHost = hostL.includes('jsls.jinritemai.com');
            console.log('[抖店调试] isDoudianFxgHost:', isDoudianFxgHost);
            console.log('[抖店调试] isDoudianJslsHost:', isDoudianJslsHost);
            
            if (isDoudianFxgHost || isDoudianJslsHost) {
                finalTargetUrl = `${urlObj.protocol}//jsls.jinritemai.com/mfa/homepage`;
                console.log('[抖店调试] 转换为finalTargetUrl:', finalTargetUrl);
            } else {
                console.log('[抖店调试] 未匹配抖店域名，保持原URL');
            }
            
        } catch (error) { 
            console.error('[抖店调试] 处理URL时出错:', error);
        }

        // 创建标签页，但不立即激活（京东平台特殊处理）
        console.log('[抖店调试] 最终打开的URL:', finalTargetUrl);
        const tab = await chrome.tabs.create({ 
            url: finalTargetUrl, 
            active: true 
        });

        // 如果是京东平台，使用简化的验证流程（类似DKD）
        if (platformCfg.isJdPlatform) {
            // 监听页面加载完成，然后进行验证
            const onUpdated = async (tabId, changeInfo) => {
                if (tabId === tab.id && changeInfo.status === 'complete') {
                    chrome.tabs.onUpdated.removeListener(onUpdated);
                    
                    // 页面加载完成后，等待一小段时间确保Cookies生效，然后验证
                    setTimeout(async () => {
                        try {
                            // 调用验证API（类似DKD的getJdInfo方法）
                            const results = await chrome.scripting.executeScript({
                                target: { tabId: tab.id },
                                func: async () => {
                                    try {
                                        // 调用验证API（与DKD完全一致）
                                        const response = await fetch('https://sff.jddj.com/api?v=1.0&appId=YNE4XWZFDHXOYGKZU5FN&api=dsm.login.o2o.vender.user.getBasicMsg', {
                                            method: 'POST',
                                            headers: {
                                                'content-type': 'application/json;charset=UTF-8',
                                                'accept': 'application/json, text/plain, */*',
                                                'origin': 'https://store.jddj.com',
                                                'dsm-platform': 'pc'
                                            },
                                            body: JSON.stringify({})
                                        });
                                        
                                        // 检查响应状态
                                        if (!response.ok) {
                                            const errorText = await response.text();
                                            return { 
                                                success: false, 
                                                error: `HTTP ${response.status}: ${errorText}`,
                                                status: response.status
                                            };
                                        }
                                        
                                        const result = await response.json();
                                        
                                        // 注意：DKD中检查的是字符串 '0'，不是数字 0
                                        if (result.code === '0' || result.code === 0) {
                                            return { success: true, result: result };
                                        } else {
                                            return { 
                                                success: false, 
                                                result: result,
                                                code: result.code,
                                                message: result.message || result.msg
                                            };
                                        }
                                    } catch (error) {
                                        return { 
                                            success: false, 
                                            error: error.message,
                                            errorName: error.name
                                        };
                                    }
                                }
                            });
                            
                            // 检查验证结果
                            if (results && results[0]) {
                                const result = results[0];
                                if (result.success) {
                                    await disableJdNetRequestRule();
                                }
                            }
                        } catch (error) {
                            // 出错时也尝试移除规则
                            try {
                                await disableJdNetRequestRule();
                            } catch (e) {}
                        }
                    }, 300); // 简化延迟到300ms（DKD风格的快速验证）
                }
            };
            chrome.tabs.onUpdated.addListener(onUpdated);
        }

        sendResponse({
            success: true,
            message: '已打开目标页面' + (platformCfg.isJdPlatform ? '（已启用京东专用规则）' : ''),
            tabId: tab.id
        });

    } catch (error) {
        sendResponse({
            success: false,
            error: error.message || '处理失败'
        });
    }
}

